home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / Other Langs / Tickle-4.0 (tcl) / src / asdtomb.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-11-18  |  11.7 KB  |  484 lines  |  [TEXT/MPS ]
  1. /*
  2. ** This source code was written by Tim Endres
  3. ** Email: time@ice.com.
  4. ** USMail: 8840 Main Street, Whitmore Lake, MI  48189
  5. **
  6. ** Some portions of this application utilize sources
  7. ** that are copyrighted by ICE Engineering, Inc., and
  8. ** ICE Engineering retains all rights to those sources.
  9. **
  10. ** Neither ICE Engineering, Inc., nor Tim Endres, 
  11. ** warrants this source code for any reason, and neither
  12. ** party assumes any responsbility for the use of these
  13. ** sources, libraries, or applications. The user of these
  14. ** sources and binaries assumes all responsbilities for
  15. ** any resulting consequences.
  16. */
  17.  
  18. #ifdef MPW3
  19. #    pragma segment MACBIN
  20. #endif
  21.  
  22. #ifndef THINK_C_PRECOMPILED
  23.  
  24. #include <types.h>
  25. #include <resources.h>
  26. #include <toolutils.h>
  27. #include <standardfile.h>
  28.  
  29. #include <fcntl.h>
  30. #include <stdio.h>
  31.  
  32. #include "defines.h"
  33.  
  34. #endif /*THINK_C_PRECOMPILED*/
  35.  
  36. #include <errno.h>
  37. #include "asd.h"
  38. #include "mb.h"
  39.  
  40.  
  41. #undef BLK_SIZE
  42. #define BLK_SIZE 1024
  43. #define iobuffer kBuffer
  44. extern char kBuffer[];
  45. /* static char                iobuffer[BLK_SIZE]; */
  46.  
  47. #ifdef TCLAPPL
  48.  
  49. SF_asd_to_mb()
  50. {
  51. Point        mypoint;
  52. SFReply        asdreply;
  53. SFReply        mbreply;
  54. SFTypeList    mytypes;
  55. FILE        *mbfile;
  56. FILE        *asdfile;
  57.  
  58.     mypoint.h = mypoint.v = 75;
  59.     mytypes[0] = 'TEXT';
  60.     MyGetFile(mypoint, "\p", NULL, (CheckOption()?-1:1), mytypes, NULL, &asdreply);
  61.     if (asdreply.good) {
  62.         MyPutFile(mypoint, "\pMacBinary Filename:", "\pfile.mb", NULL, &mbreply);
  63.         if (mbreply.good) {
  64.             p2cstr(mbreply.fName);
  65.             p2cstr(asdreply.fName);
  66.             Feedback("Apple Single/Double to MacBinary  '%s' -> '%s'\n",
  67.                             asdreply.fName, mbreply.fName);
  68.             SetVol(NULL, asdreply.vRefNum);
  69.             asdfile = fopen(asdreply.fName, "r");
  70.             if (asdfile == NULL) {
  71.                 Feedback("Error #%d opening '%s'", errno, asdreply.fName);
  72.                 return FAILURE;
  73.                 }
  74.             SetVol(NULL, mbreply.vRefNum);
  75.             mbfile = fopen(mbreply.fName, "w");
  76.             if (mbfile == NULL) {
  77.                 Feedback("Error #%d opening '%s'", errno, mbreply.fName);
  78.                 fclose(asdfile);
  79.                 return FAILURE;
  80.                 }
  81.             
  82.             yield_menus(YIELD_ON);
  83.  
  84.             do_asd_to_mb(asdreply.fName, asdfile, mbreply.fName, mbfile);
  85.             
  86.             WatchCursorOn();
  87.             fclose(asdfile);
  88.             fclose(mbfile);
  89.  
  90.             yield_menus(YIELD_OFF);
  91.             UInitCursor();
  92.             }
  93.         }
  94.     }
  95.  
  96. #endif
  97.  
  98. do_asd_to_mb(inname, infile, outname, outfile)
  99. char    *inname;
  100. FILE    *infile;
  101. char    *outname;
  102. FILE    *outfile;
  103. {
  104. int    result = SUCCESS;
  105. long    bytes;
  106.  
  107.     bytes = fread(&asd_header, 1, sizeof(asd_hdr), infile);
  108.     if (bytes != sizeof(asd_hdr)) {
  109.         Feedback("Error #%d reading AppleSingle header bytes.", errno);
  110.         result = FAILURE;
  111.         }
  112.     else switch (asd_header.magic) {
  113.         case MAGIC_APPLE_SINGLE: /* AppleSingle */
  114.             Feedback("Apple Single -> Macintosh.");
  115.             result = apple_single_to_mb(inname, infile, outname, outfile, &asd_header);
  116.             break;
  117.         case MAGIC_APPLE_DOUBLE: /* AppleDouble */
  118.             Feedback("Apple Double -> Macintosh.");
  119.             result = apple_double_to_mb(inname, infile, outname, outfile, &asd_header);
  120.             break;
  121.         default:
  122.             Feedback("Unknown magic number 0x%08lx. Not processed.", asd_header.magic);
  123.             result = FAILURE;
  124.             break;
  125.         }
  126.  
  127.     return result;
  128.     }
  129.  
  130. apple_single_to_mb(inname, infile, outname, outfile, header)
  131. char    *inname;
  132. FILE    *infile;
  133. char    *outname;
  134. FILE    *outfile;
  135. asd_hdr    *header;
  136. {
  137. int        i;
  138. int        got_data, got_rsrc, got_fndr;
  139. int        i_data, i_rsrc, i_fndr;
  140. long    now;
  141.  
  142. #pragma unused (outname)
  143.  
  144.     got_data = got_rsrc = got_fndr = 0;
  145.  
  146. #ifdef TCLAPPL
  147.     print_asd_hdr(header);
  148. #endif
  149.  
  150.     RotateCursor(32);
  151.     DoYield();
  152.  
  153.     for (i=0; i < header->entries; i++) {
  154.         fread(&the_entries[i], 1, sizeof(asd_entry), infile);
  155. #ifdef TCLAPPL
  156.         print_asd_entry(&the_entries[i]);
  157. #endif
  158.         switch (the_entries[i].id) {
  159.             case ASDID_DATA_FORK: got_data = 1; i_data = i; break;
  160.             case ASDID_RSRC_FORK: got_rsrc = 1; i_rsrc = i; break;
  161.             case ASDID_FNDR_FORK: got_fndr = 1; i_fndr = i; break;
  162.             }
  163.         }
  164.  
  165.     mb_header->zero1 = 0;
  166.     mb_header->zero2 = 0;
  167.     mb_header->zero3 = 0;
  168.     mb_header->protected = 0;
  169.  
  170.     strcpy(mb_header->name, inname);
  171.     mb_header->nlen = (unsigned char) strlen(inname);
  172.  
  173.     RotateCursor(32);
  174.     DoYield();
  175.  
  176.     if (! got_fndr) {
  177.         Feedback("NOTE: No Finder Information. Defaulting.");
  178.         strncpy(mb_header->type, "????", 4);
  179.         strncpy(mb_header->creator, "????", 4);
  180.         mb_header->flags = 0;
  181.         memset(mb_header->location, 0, sizeof(mb_header->location));
  182.         }
  183.     else {
  184.         get_asd_fndr_data(infile, &the_entries[i_fndr], &g_asd_finder);
  185. #ifdef TCLAPPL
  186.         print_asd_fndr(&g_asd_finder);
  187. #endif
  188.         memcpy(mb_header->type, &g_asd_finder.fdType, 4);
  189.         memcpy(mb_header->creator, &g_asd_finder.fdCreator, 4);
  190.         mb_header->flags = g_asd_finder.fdFlags;
  191.         memcpy(mb_header->location, g_asd_finder.fdLocation,
  192.                 sizeof(mb_header->location));
  193.         }
  194.         
  195.     if (got_data) {
  196.         move_long_to_char(the_entries[i_data].length, mb_header->dflen);
  197.         }
  198.     else {
  199.         memset(mb_header->dflen, 0, sizeof(mb_header->dflen));
  200.         }
  201.  
  202.     if (got_rsrc) {
  203.         move_long_to_char(the_entries[i_rsrc].length, mb_header->rflen);
  204.         }
  205.     else {
  206.         memset(mb_header->rflen, 0, sizeof(mb_header->rflen));
  207.         }
  208.  
  209.     now = time(0); now = UNIX_TO_MAC_TIME(now);
  210.     move_long_to_char(now, mb_header->cdate);
  211.     move_long_to_char(now, mb_header->mdate);
  212.  
  213.     RotateCursor(32);
  214.     DoYield();
  215.  
  216.     Feedback("DATA Fork contained %ld bytes.", the_entries[i_data].length);
  217.     Feedback("RSRC Fork contained %ld bytes.", the_entries[i_rsrc].length);
  218.     Feedback("Writing MacBinary header...");
  219.     fwrite(mb_header, 1, MAC_BINARY_HDR_SIZE, outfile);
  220.  
  221.     if (got_data && (the_entries[i_data].length > 0)) {
  222.         Feedback("Writing DATA fork...");
  223.         do_data_copy(infile, the_entries[i_data].offset, outfile, -1, the_entries[i_data].length);
  224.         }
  225.  
  226.     if (got_rsrc && the_entries[i_rsrc].length) {
  227.         Feedback("Writing RSRC fork...");
  228.         do_data_copy(infile, the_entries[i_rsrc].offset, outfile, -1, the_entries[i_rsrc].length);
  229.         }
  230.  
  231.     }
  232.  
  233. #ifdef TCLAPPL
  234.  
  235. apple_double_to_mb(rname, rfile, outname, outfile, header)
  236. char    *rname;
  237. FILE    *rfile;
  238. char    *outname;
  239. FILE    *outfile;
  240. asd_hdr    *header;
  241. {
  242. FILE    *dfile = NULL;
  243. SFReply    myreply;
  244. Point    mypoint;
  245. SFTypeList    mytypes;
  246. int        i;
  247. int        got_data, got_rsrc, got_fndr, got_path;
  248. int        i_data = 0, i_rsrc, i_fndr, i_path;
  249. long    now, bytes;
  250. char    dname[256];
  251.  
  252. #pragma unused (outname)
  253.  
  254.     got_data = got_rsrc = got_fndr = 0;
  255.  
  256. #ifdef TCLAPPL
  257.     print_asd_hdr(header);
  258. #endif
  259.  
  260.     the_entries[i_data].id = ASDID_DATA_FORK;
  261.     the_entries[i_data].offset = 0;
  262.     the_entries[i_data].length = 0;
  263.     
  264.     RotateCursor(32);
  265.     DoYield();
  266.  
  267.     for (i=1; i <= header->entries; i++) {
  268.         fread(&the_entries[i], 1, sizeof(asd_entry), rfile);
  269. #ifdef TCLAPPL
  270.         print_asd_entry(&the_entries[i]);
  271. #endif
  272.         switch (the_entries[i].id) {
  273.             case ASDID_RSRC_FORK: got_rsrc = 1; i_rsrc = i; break;
  274.             case ASDID_FNDR_FORK: got_fndr = 1; i_fndr = i; break;
  275.             case ASDID_DATA_PATH: got_path = 1; i_path = i; break;
  276.             }
  277.         }
  278.  
  279.     RotateCursor(32);
  280.     DoYield();
  281.  
  282.     if (got_path) {
  283.         if (the_entries[i_path].length >= sizeof(dname)-1) {
  284.             Feedback("Real Name Too Long: %d > %d. Truncating.",
  285.                         the_entries[i_path].length, sizeof(dname)-1);
  286.             the_entries[i_path].length = sizeof(dname) - 1;
  287.             }
  288.         
  289.         bytes = fread(dname, 1, the_entries[i_path].length, rfile);
  290.         if (bytes > the_entries[i_path].length) {
  291.             Feedback("Real Name Too Long: %d > %d. Truncating to '%.*s'.",
  292.                         bytes, the_entries[i_path].length, the_entries[i_path].length, dname);
  293.             dname[the_entries[i_path].length] = '\0';
  294.             }
  295.         else if (bytes < the_entries[i_path].length) {
  296.             Feedback("Couldn't Read All Of Real Name: %d < %d. Using '%.*s'.",
  297.                         bytes, sizeof(dname)-1, bytes, dname);
  298.             dname[bytes] = '\0';
  299.             }
  300.         else {
  301.             dname[bytes] = '\0';
  302.             }
  303.         Feedback("Opening Real Name: '%s'.", dname);
  304.         dfile = fopen(dname, "r");
  305.         if (dfile != NULL)
  306.             got_data = 1;
  307.         }
  308.     
  309.     RotateCursor(32);
  310.     DoYield();
  311.  
  312.     if (! got_data) {
  313.         if (rname[0] == '%')
  314.             strcpy(dname, &rname[1]);
  315.         else {
  316.             sprintf(dname, "%%%s", rname);
  317.             }
  318.         Feedback("Trying Data Name: '%s'.", dname);
  319.         dfile = fopen(dname, "r");
  320.         if (dfile == NULL) {
  321.             mypoint.h = mypoint.v = 75;
  322.             MyGetFile(mypoint, "\pWhere is data fork?", NULL, -1, mytypes, NULL, &myreply);
  323.             if (myreply.good) {
  324.                 sprintf(dname, "%.*s", myreply.fName[0], &myreply.fName[1]);
  325.                 SetVol(NULL, myreply.vRefNum);
  326.                 dfile = fopen(dname, "r");
  327.                 if (dfile != NULL)
  328.                     got_data = 1;
  329.                 else
  330.                     return FAILURE;
  331.                 }
  332.             else {
  333.                 if (! AskYesNo("Do you just want an empty data fork?", 1))
  334.                     return CANCEL;
  335.                 }
  336.             }
  337.         else
  338.             got_data = 1;
  339.         }
  340.     
  341.     RotateCursor(32);
  342.     DoYield();
  343.  
  344.     if (dfile != NULL) {
  345.         the_entries[i_data].offset = 0;
  346.         fseek(dfile, 0, SEEK_END);
  347.         the_entries[i_data].length = ftell(dfile);
  348.         fseek(dfile, 0, SEEK_SET);
  349.         }
  350.     else {
  351.         the_entries[i_data].offset = 0;
  352.         the_entries[i_data].length = 0;
  353.         }
  354.     move_long_to_char(the_entries[i_data].length, mb_header->dflen);
  355.     
  356.     mb_header->zero1 = 0;
  357.     mb_header->zero2 = 0;
  358.     mb_header->zero3 = 0;
  359.     mb_header->protected = 0;
  360.  
  361.     strcpy(mb_header->name, rname);
  362.     mb_header->nlen = (unsigned char) strlen(rname);
  363.  
  364.     RotateCursor(32);
  365.     DoYield();
  366.  
  367.     if (! got_fndr) {
  368.         Feedback("NOTE: No Finder Information. Defaulting.");
  369.         strncpy(mb_header->type, "????", 4);
  370.         strncpy(mb_header->creator, "????", 4);
  371.         mb_header->flags = 0;
  372.         memset(mb_header->location, 0, sizeof(mb_header->location));
  373.         }
  374.     else {
  375.         get_asd_fndr_data(rfile, &the_entries[i_fndr], &g_asd_finder);
  376. #ifdef TCLAPPL
  377.         print_asd_fndr(&g_asd_finder);
  378. #endif
  379.         memcpy(mb_header->type, &g_asd_finder.fdType, 4);
  380.         memcpy(mb_header->creator, &g_asd_finder.fdCreator, 4);
  381.         mb_header->flags = g_asd_finder.fdFlags;
  382.         memcpy(mb_header->location, g_asd_finder.fdLocation,
  383.                 sizeof(mb_header->location));
  384.         }
  385.         
  386.     if (got_rsrc) {
  387.         move_long_to_char(the_entries[i_rsrc].length, mb_header->rflen);
  388.         }
  389.     else {
  390.         memset(mb_header->rflen, 0, sizeof(mb_header->rflen));
  391.         }
  392.  
  393.     now = time(0); now = UNIX_TO_MAC_TIME(now);
  394.     move_long_to_char(now, mb_header->cdate);
  395.     move_long_to_char(now, mb_header->mdate);
  396.  
  397.     RotateCursor(32);
  398.     DoYield();
  399.  
  400.     Feedback("DATA Fork contained %ld bytes.", the_entries[i_data].length);
  401.     Feedback("RSRC Fork contained %ld bytes.", the_entries[i_rsrc].length);
  402.     Feedback("Writing MacBinary header...");
  403.     fwrite(mb_header, 1, MAC_BINARY_HDR_SIZE, outfile);
  404.  
  405.     if (the_entries[i_data].length > 0) {
  406.         Feedback("Writing DATA fork. Off %ld Len %ld dfile = x%08lX ",
  407.                     ftell(outfile), the_entries[i_data].length, dfile);
  408.         do_data_copy(dfile, the_entries[i_data].offset,
  409.                         outfile, (long)-1, the_entries[i_data].length);
  410.         }
  411.  
  412.     if (got_rsrc && the_entries[i_rsrc].length > 0) {
  413.         Feedback("Writing RSRC fork. Off %ld Len %ld rfile = x%08lX ",
  414.                     ftell(outfile), the_entries[i_rsrc].length, rfile);
  415.         do_data_copy(rfile, the_entries[i_rsrc].offset,
  416.                         outfile, -1, the_entries[i_rsrc].length);
  417.         }
  418.         
  419.     if (dfile) {
  420.         WatchCursorOn();
  421.         fclose(dfile);
  422.         }
  423.     }
  424.  
  425. #endif /* TCLAPPL */
  426.  
  427.  
  428. move_long_to_char(lng, ch)
  429. long    lng;
  430. char    *ch;
  431. {
  432.     ch[0] = (unsigned char) ((lng >> 24) & 0x000000FF);
  433.     ch[1] = (unsigned char) ((lng >> 16) & 0x000000FF);
  434.     ch[2] = (unsigned char) ((lng >> 8)  & 0x000000FF);
  435.     ch[3] = (unsigned char) (lng & 0x000000FF);
  436.     }
  437.  
  438. do_data_copy(infile, inoffset, outfile, outoffset, length)
  439. FILE        *infile;
  440. long        inoffset;
  441. FILE        *outfile;
  442. long        outoffset;
  443. long        length;
  444. {
  445. int            blocks, residue;
  446.  
  447.     Feedback("do_data_copy: in_offset = %ld out_offset = %ld ",
  448.                 inoffset, outoffset);
  449.     
  450.     if (inoffset != -1)
  451.         fseek(infile, inoffset, SEEK_SET);
  452.     if (outoffset != -1)
  453.         fseek(outfile, outoffset, SEEK_SET);
  454.  
  455.     Feedback("do_data_copy: length = %ld BLKSZ %d ", length, BLK_SIZE);
  456.     blocks = length / BLK_SIZE;
  457.     residue = length % BLK_SIZE;
  458.  
  459.     Feedback("do_data_copy: blks = %ld res %ld", blocks, residue);
  460.     for ( ; blocks ; blocks--) {
  461.         RotateCursor(32);
  462.         DoYield();
  463.         if (pause_op)
  464.             while (pause_op)
  465.                 pausing();
  466.         
  467.         if (cancel_current_op)
  468.             return CANCEL;
  469.  
  470.         fread(iobuffer, 1, BLK_SIZE, infile);
  471.         fwrite(iobuffer, 1, BLK_SIZE, outfile);
  472.         }
  473.  
  474.     if (residue) {
  475.         RotateCursor(32);
  476.         DoYield();
  477.  
  478.         memset(iobuffer, 0, BLK_SIZE);
  479.         fread(iobuffer, 1, residue, infile);
  480.         fwrite(iobuffer, 1, BLK_SIZE, outfile);
  481.         }
  482.     }
  483.  
  484.